/**
 * 基础类
 * 提供事件处理机制和对象生命周期管理功能，是所有可销毁对象的基类。
 * 
 * @class BaseClass
 */
class BaseClass {
  /**
   * 构造函数
   * 
   * @constructor
   * @param {Object} options - 配置选项对象
   */
  constructor(options = {}) {
    /**
     * 配置选项对象
     * 
     * @type {Object}
     * @protected
     */
    this.options = options;
    
    /**
     * 事件监听器映射
     * 
     * @type {Object.<string, Array<Function>>}
     * @private
     */
    this._eventListeners = {};
    
    /**
     * 对象销毁状态标记
     * 
     * @type {boolean}
     * @private
     */
    this._destroyed = false;
  }
  
  /**
   * 销毁对象
   * 清理所有资源，注销所有事件监听器，并将对象标记为已销毁状态。
   * 销毁后的对象不应再被使用。
   * 
   * @method destroy
   * @returns {void}
   */
  destroy() {
    if (this._destroyed) {
      return;
    }
    
    // 清空所有事件监听器
    this._eventListeners = {};
    
    // 标记为已销毁
    this._destroyed = true;
    
    // 触发destroy事件
    this.fire('destroy');
  }
  
  /**
   * 触发事件
   * 调用指定类型事件的所有注册回调函数。
   * 
   * @method fire
   * @param {string} type - 事件类型
   * @returns {void}
   */
  fire(type) {
    if (this._destroyed) {
      return;
    }
    
    const listeners = this._eventListeners[type];
    if (!listeners || listeners.length === 0) {
      return;
    }
    
    // 复制监听器数组，避免在回调中修改数组导致的问题
    const listenersCopy = listeners.slice();
    
    // 执行所有回调函数
    for (let i = 0; i < listenersCopy.length; i++) {
      try {
        listenersCopy[i].call(this);
      } catch (error) {
        console.error(`Error in event listener for ${type}:`, error);
      }
    }
  }
  
  /**
   * 检查对象是否已销毁
   * 
   * @method isDestroyed
   * @returns {boolean} 对象是否已经销毁，销毁后不能再次使用
   */
  isDestroyed() {
    return this._destroyed;
  }
  
  /**
   * 注销事件
   * 移除指定类型事件的所有监听器。
   * 
   * @method off
   * @param {string} type - 事件类型
   * @returns {void}
   */
  off(type) {
    if (this._destroyed) {
      return;
    }
    
    if (type && this._eventListeners[type]) {
      delete this._eventListeners[type];
    }
  }
  
  /**
   * 注册事件
   * 添加指定类型事件的回调函数。
   * 
   * @method on
   * @param {string} type - 事件类型
   * @param {Function} callback - 回调函数
   * @returns {void}
   */
  on(type, callback) {
    if (this._destroyed) {
      return;
    }
    
    if (!type || typeof callback !== 'function') {
      return;
    }
    
    if (!this._eventListeners[type]) {
      this._eventListeners[type] = [];
    }
    
    this._eventListeners[type].push(callback);
  }
}

export default BaseClass;